009-算法面试必备-基础数据结构（链表，栈，队列）

今天来三个基础数据结构的学习吧。链表，栈，队列。

主要是看看怎么实现的。思想很重要。

想说的是，对于非计算机专业同学，需要自学数据结构，我曾经在链表，栈，队列这几章中来回的徘徊。

不是我搞不懂这些数据结构，是我进行不下去了，直到有一天，我脚踏实地的写出来，才算弄明白。

实现一个链表

//实现一个链表
class Node <E>{
	Node next = null;
	E data ;
	public Node(E data){
		this.data = data;
	}
}
//一个.java文件中只有一个public class文件
public class MyLinkedList <E> {
	Node head = null;    //整个链表的头结点
	public void addNode(E d){
		Node newNode = new Node(d);
		if(head == null){
			head = newNode;
			return;
		}
		//遍历链表的头结点
		Node temp = head;
		while(temp.next != null){
			temp = temp.next;
		}
		temp.next = newNode;
	}
	//删除链表的第几个节点
	public boolean deleteNode(int index){
		if(index < 1 || index >length()){
			return false;
		}
		//删除链表第一个元素
		if(index == 1){
			head = head.next;
			return true;
		}
		int i = 2;
		Node preNode = head;
		Node curNode = preNode.next;
		while(curNode != null){
			if(i == index){
				preNode.next = curNode.next;   //删除节点
				return true;
			}
			preNode = curNode;               //遍历节点
			curNode = curNode.next;
			i++;
		}
		return true;			
	}
	public int length(){
		int length = 0;
		Node temp = head;
		while( temp != null){
			length++;
			temp = temp.next;
		}
		return length;
	}
	public void printList(){
		Node<E> temp = head;
		while( temp != null){
			System.out.println(temp.data);
			temp = temp.next;
		}
	}
	public static void  main(String[] args){
		MyLinkedList<Integer> list = new MyLinkedList<Integer>();
		list.addNode(1);
		list.addNode(2);
		list.addNode(3);
		list.printList();
		
	}
}

实现一个栈

class Node<E> {
	Node<E> next = null;
	E data;
	public Node(E data){
		this.data = data;
	}
}
//使用链表实现栈，需要使用一个指针就可以了
public class ArrayStack<E> {
	Node<E> top = null;
	public boolean isEmpty(){
		return top == null;
	}
	//入栈
	public void push(E data){
		Node<E> newNode = new Node<E>(data);
		newNode.next = top;  //对于栈来说，后入先出LIFO
		top = newNode;
	}
	//出栈
	public E pop(){
		if(this.isEmpty()){
			return null;
		}
		E data = top.data;
		top = top.next;
		return data;
	}
	//返回最节点上的值
	public E peek(){
		if(isEmpty()){
			return null;
		}
		return top.data;
	}
	public static void main(String[] args){
		ArrayStack<Integer> st = new ArrayStack<Integer>();
		st.push(1);
		st.push(2);
		st.push(3);
		System.out.println(st.pop());
		System.out.println(st.pop());
		System.out.println(st.pop());
	}
}

实现一个队列

//利用链表实现队列
//队列的思想是：先进先出
//记住这种队列的实现
class Node<E>{
	Node<E> next = null;
	E data;
	public Node(E data){
		this.data = data;
	}
}
//先进先出，使用两个指针来表示，否则，在pop的时候,需要遍历，增加程序的复杂度
public class ArrayQueue<E> {
	private Node<E> head = null;
	private Node<E> tail = null;
	
	public boolean isEmpty(){
		return head == tail;
	}
	public void put(E data){  //入队的时候，尾巴增长
		Node<E> newNode = new Node<E> (data);
		if(head == null && tail == null){ //队列为空
			head = tail = newNode;
		}else{
			tail.next = newNode;
			tail = newNode;
		}
	}
	public E pop(){       //出队的时候，从头开始出队
		if(this.isEmpty()){
			return null;
		}
		E data = head.data;
		head = head.next;
		return data;
	}
	public int size(){
		Node<E> tmp = head;
		int n = 0;
		while(tmp != null){
			n++;
			tmp = tmp.next;
		}
		return n;
	}
	
	public static void main(String[] args){
		ArrayQueue<Integer> q = new ArrayQueue<Integer>();
		q.put(1);
		q.put(2);
		q.put(3);
		System.out.println("队列的长度" + q.size());
		System.out.println("队列首元素" + q.pop());
		System.out.println("队列的长度" + q.size());
		System.out.println("队列的首元素" + q.pop());
	}	
}